home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / SoundAndMusic / cmix / Minc / trees.c < prev    next >
C/C++ Source or Header  |  1991-03-16  |  13KB  |  779 lines
  1.  
  2. /*
  3. *   intermediate representation
  4. */
  5.  
  6.  
  7. #include "defs.h"    
  8. #include <stdio.h>
  9.  
  10. double   *disp_args;
  11. int     arg_count;
  12. double *arg_list_stack[MAXSTACK];
  13. int    arg_count_stack[MAXSTACK];
  14. int    stack_ptr;
  15. double  parse_dispatch();
  16.  
  17. char    buf[500];
  18. extern Tree tp1,tp2,tp3;
  19. extern int i1,i2,i3;
  20. extern double f1,f2,f3;
  21. /*
  22. *   floating point comparisons:
  23. *   f1 < f2  ==> -1
  24. *   f1 = f2  ==> 0
  25. *   f1 > f2  ==> 1 
  26. */
  27. /*  useless funtion */
  28. foo(){};
  29. foo2(){};
  30.  
  31.  
  32. cmp (f1,f2)
  33. double f1,f2;
  34. {
  35. foo();
  36.     if (fabs(f1-f2)< EPS){// printf("cmp=%g %g %g \n",f1,f2,fabs(f1-f2));
  37.             return (0);
  38.             }
  39.     if ((f1-f2)   > EPS) { //printf("cmp > %g %g %g \n",f1,f2,fabs(f1-f2)); 
  40.             return (1);
  41.             }
  42.     if ((f2-f1)   > EPS) {// printf("cmp <%g %g %g \n",f1,f2,fabs(f1-f2)); 
  43.             return (-1);
  44.             }
  45. }
  46.  
  47.  
  48.  
  49.  
  50.  
  51. Tree  node(op,kind)
  52. int    op;
  53. int    kind;
  54. {
  55. Tree    tp1;    
  56.  
  57.     tp1 = (Tree) emalloc(sizeof(struct tree));
  58.     tp1->op = op;
  59.     tp1->kind = kind;
  60.     tp1->u.child[0] = NULL;
  61.     tp1->u.child[1] = NULL;
  62.     tp1->u.child[2] = NULL;
  63.     tp1->u.child[3] = NULL;
  64.     return tp1;
  65. }
  66.  
  67.  
  68. /*
  69. Tree   tproc(){};
  70. */
  71.  
  72. Tree   tnoop()
  73. {
  74. Tree    tp1;
  75. foo();
  76.     tp1=node(FREE,TNOOP);
  77. return (tp1);
  78. }
  79.  
  80.  
  81. Tree   tseq(e1,e2)
  82. Tree    e1,e2;
  83. {
  84. Tree    tp1;
  85. foo();
  86.     tp1=node(FREE,SEQ);
  87.  
  88.     tp1->u.child[0] = e1;
  89.     tp1->u.child[1] = e2;
  90.     return tp1;
  91.     
  92. }
  93.  
  94. Tree    top(op,e1,e2)
  95. Tree    e1,e2;
  96. int    op;
  97. {
  98.  
  99. Tree    tp1;
  100. foo();
  101.  
  102.     tp1 =node (op,OP);
  103.     tp1->u.child[0] = e1;
  104.     tp1->u.child[1] = e2;
  105.     return tp1;
  106. }
  107.  
  108. Tree    tunop(op,e1)
  109. Tree    e1;
  110. int    op;
  111. {
  112. Tree    tp1;
  113. foo();
  114.  
  115.     tp1 = node(op,UNOP);
  116.     tp1->u.child[0] = e1;
  117.     return tp1;
  118. }
  119.  
  120. Tree    tconvert(op,e1)
  121. int    op;
  122. Tree    e1;
  123. {
  124.  
  125. Tree    tp1;
  126. foo();
  127.  
  128.     tp1=node (op,CONVERT);
  129.     tp1->u.child[0] = e1;
  130.     return tp1;
  131. }
  132.  
  133. /*
  134. Tree     tfetch(){};
  135. */
  136.  
  137. Tree    tstore(e1,e2)
  138. Tree    e1,e2;
  139. {
  140.  
  141. Tree    tp1;
  142. foo();
  143.  
  144.  
  145.     tp1 = node(FREE,STORE);
  146.     tp1->u.child[0] = e1;
  147.     tp1->u.child[1] = e2;
  148.     return tp1;
  149.  
  150. }
  151.  
  152.     
  153. /* 
  154. Tree tmove(){};
  155. */
  156.  
  157. /*   not used ********************* 
  158. Tree    teseq(stm,e1)
  159. Tree    stm,e1;
  160. {
  161. Tree    tp1;
  162. foo();
  163.     tp1 = node(FREE,ESEQ);
  164.     tp1->u.child[0] = stm;
  165.     tp1->u.child[1] = e1;
  166.     return tp1;
  167. }
  168. */
  169.  
  170. /*
  171. Tree    tbool(){}
  172. */
  173.  
  174. /*
  175. *  converts symbol table entry into tree
  176. *  or initialize tree node to a symbol entry
  177. */
  178.  
  179. Tree    tname(sym)    
  180. SYMBOL  *sym;
  181.  
  182. {
  183.  
  184. Tree    tp1;
  185. foo();
  186.  
  187.     tp1 = node(FREE,NAME);
  188.     tp1->u.sym = sym;    
  189.     return tp1;
  190. }
  191.  
  192. Tree    tconst(ival)
  193. int    ival;
  194. {
  195. Tree    tp1;
  196. foo();
  197.     tp1 = node(FREE,CONST);
  198.     tp1->u.ival = ival;
  199.     return tp1;
  200. }
  201.  
  202. Tree    tconstf(fval)
  203. double    fval;
  204. {
  205. Tree    tp1;
  206. foo();
  207.     tp1 = node(FREE,CONSTF);
  208.     tp1->u.fval = fval;
  209.     return tp1;
  210. }
  211.  
  212. /*
  213. Tree falloc(){}
  214. Tree ttemp(){}
  215. */
  216.  
  217.  
  218. Tree  tcall(e1,str)
  219. Tree    e1;   /*arguments*/
  220. char    *str;    /* name of function to call */
  221. {
  222.  
  223. Tree    tp1;
  224. foo();
  225.     tp1 = node(FREE,CALL);
  226.     tp1->x.fctname = str;
  227.     tp1->u.child[0] = e1;
  228.     return tp1;
  229. }
  230.  
  231.  
  232. Tree    tcand(test1,test2)
  233. Tree    test1,test2;
  234. {
  235.  
  236. Tree    tp1;
  237. foo();
  238.     tp1 = node(FREE,CAND);
  239.     tp1->u.child[0] = test1;
  240.     tp1->u.child[1] = test2;
  241.     return tp1;
  242. }
  243.  
  244. Tree    tcor(test1,test2)
  245. Tree    test1,test2;
  246. {
  247.  
  248. Tree    tp1;
  249. foo();
  250.     tp1 = node(FREE,COR);
  251.     tp1->u.child[0] = test1;
  252.     tp1->u.child[1] = test2;
  253.     return tp1;
  254. }
  255.     
  256.  
  257.     
  258.  
  259. Tree    tnot(test1)
  260. Tree    test1;
  261. {
  262.  
  263. Tree    tp1;
  264. foo();
  265.     tp1 = node(FREE,NOT);
  266.     tp1->u.child[0] = test1;
  267.     return tp1;
  268. }
  269.  
  270. Tree    trel(op,e1,e2)
  271. int    op;
  272. Tree    e1,e2;
  273. {
  274.  
  275. Tree    tp1;
  276. foo();
  277.     tp1 = node (op,REL);
  278.     tp1->u.child[0] = e1;
  279.     tp1->u.child[1] = e2;
  280.     return tp1;
  281.  
  282. }
  283.  
  284. Tree targ(e1,args)
  285. Tree e1,args;
  286. {
  287.  
  288. Tree    tp1;
  289. foo();
  290.     tp1 = node(FREE,ARG);
  291.     tp1->u.child[0] = e1;
  292.     tp1->u.child[1] = args;
  293.     return tp1;
  294. }
  295.  
  296. Tree tnoargs()
  297. {
  298. Tree    tp1;
  299. foo();
  300.     tp1 = node(FREE,NOARGS);
  301.     return tp1;
  302. }
  303.  
  304.  
  305. Tree tif(e1,e2)
  306. Tree    e1,e2;
  307. {
  308.  
  309. Tree    tp1;
  310. foo();
  311.     tp1 = node (FREE,TIF);
  312.     tp1->u.child[0] = e1;
  313.     tp1->u.child[1] = e2;
  314.     return tp1;
  315. }
  316.  
  317.  
  318. Tree tifelse(e1,e2,e3)
  319. Tree    e1,e2,e3;
  320. {
  321.  
  322. Tree    tp1;
  323. foo();
  324.     tp1 = node (FREE,TIFELSE);
  325.     tp1->u.child[0] = e1;
  326.     tp1->u.child[1] = e2;
  327.     tp1->u.child[2] = e3;
  328.     return tp1;
  329. }
  330.  
  331.  
  332. Tree tfor(e1,e2,e3,e4)
  333. Tree    e1,e2,e3,e4;
  334. {
  335.  
  336. Tree    tp1;
  337. foo();
  338.     tp1 = node (FREE,TFOR);
  339.     tp1->u.child[0] = e1;
  340.     tp1->u.child[1] = e2;
  341.     tp1->u.child[2] = e3;
  342.     tp1->u.child[3] = e4;
  343.     return tp1;
  344. }
  345.  
  346. Tree twhile(e1,e2)
  347. Tree    e1,e2;
  348. {
  349.  
  350. Tree    tp1;
  351. foo();
  352.     tp1 = node (FREE,TWHILE);
  353.     tp1->u.child[0] = e1;
  354.     tp1->u.child[1] = e2;
  355.     return tp1;
  356. }
  357.  
  358. /*
  359. *
  360. *
  361. *   This recursive function interprets the intermediate code 
  362. *
  363. */
  364.  
  365.  
  366. Tree exct(tp)
  367. Tree   tp;
  368.  
  369. {
  370. int i;
  371.  
  372.  
  373. if (tp == NULL) return (NULL);
  374.  
  375. switch (tp->kind)  {
  376.  
  377.    case    SEQ: {
  378.         exct(tp->u.child[0]);            
  379.         exct(tp->u.child[1]);            
  380.         break;
  381.     }
  382.     /*  puts value and type into symbol pted to by child[0]u.sym */
  383.    case    STORE: {
  384.         /* TBD: include handlng of different types */
  385.         tp->u.child[0]->u.sym->v.fval = exct(tp->u.child[1])->v.fval;
  386.         tp->u.child[0]->u.sym->type = tp->u.child[1]->type;
  387.         tp->v.fval = tp->u.child[0]->u.sym->v.fval;
  388.         tp->type = tp->u.child[1]->type;
  389.         break;
  390.     }
  391.     
  392.      /*  assign what's in the symobol into tree's value field */ 
  393.    case    NAME:  {
  394.         tp->type = tp->u.sym->type;
  395.         tp->v.fval = tp->u.sym->v.fval;
  396.         break;
  397.     }
  398.    case    CONST: {
  399.         tp->type = T_INT;
  400.         tp->v.ival = tp->u.ival;
  401.         break;
  402.     }
  403.    case    CONSTF: {
  404.         tp->type = T_FLOAT;
  405.         tp->v.fval = tp->u.fval;
  406.         break;
  407.     }
  408.    case ARG:    {
  409.         exct(tp->u.child[0]);
  410.         if (arg_count ==MAXDISPARGS) 
  411.             i_error("exeeded maximum number of arguments for a function call"); 
  412.         disp_args[arg_count++] = exct(tp->u.child[1])->v.fval;
  413.         break;
  414.         }
  415.    case NOARGS:  {  /* do nothing */
  416.         break;
  417.         }
  418.     
  419.    case    CALL:   {
  420.          /* TBD:  distinguish between internal or dispatcher function */    
  421.  
  422.         push_args ();    
  423.         exct(tp->u.child[0]);
  424.  
  425.         for (i=arg_count;i<MAXDISPARGS;i++) disp_args[i]=0;
  426.         tp->v.fval = parse_dispatch (tp->x.fctname,
  427.                             disp_args,arg_count);
  428.         pop_args ();
  429.         tp->type =  T_FLOAT;
  430.         
  431.         break;
  432.     }
  433.     
  434.    case    NOT: {
  435.         tp->type = T_FLOAT;
  436.         if(cmp(0.0,exct(tp->u.child[0])->v.fval)==0)
  437.             tp->v.fval = 1.0;
  438.         else    tp->v.fval = 0.0;
  439.         break;
  440.     }
  441.    case    CAND: {
  442.         tp->type = T_FLOAT;
  443.         tp->v.fval = 0.0;
  444.         if(cmp(0.0,exct(tp->u.child[0])->v.fval)!= 0)
  445.            if(cmp(0.0,exct(tp->u.child[1])->v.fval)!= 0)
  446.             { tp->type = T_FLOAT;
  447.               tp->v.fval = 1.0;
  448.             }
  449.         break;
  450.     }
  451.    case    REL:  {
  452.         tp->type = T_FLOAT;
  453.         
  454.         switch((int)tp->op)  {
  455.         
  456.        case EQ: {
  457.          if(cmp(exct(tp->u.child[0])->v.fval,
  458.             exct(tp->u.child[1])->v.fval)== 0)
  459.         tp->v.fval = 1.0;
  460.          else 
  461.         tp->v.fval = 0.0;
  462.          break;        
  463.         }
  464.        case NEQ: {
  465.          if(cmp(exct(tp->u.child[0])->v.fval,
  466.             exct(tp->u.child[1])->v.fval)== 0)
  467.         tp->v.fval = 0.0;
  468.          else 
  469.         tp->v.fval = 1.0;
  470.          break;        
  471.         }
  472.     case LT: {
  473.          if(cmp(exct(tp->u.child[0])->v.fval,
  474.             exct(tp->u.child[1])->v.fval)== -1)
  475.         tp->v.fval = 1.0;
  476.          else 
  477.         tp->v.fval = 0.0;
  478.          break;        
  479.         }
  480.     case    GT: {
  481.          if(cmp(exct(tp->u.child[0])->v.fval,
  482.             exct(tp->u.child[1])->v.fval)== 1)
  483.         tp->v.fval = 1.0;
  484.          else 
  485.         tp->v.fval = 0.0;
  486.          break;        
  487.         }
  488.     case    LEQ: {
  489.          if(cmp(exct(tp->u.child[0])->v.fval,
  490.             exct(tp->u.child[1])->v.fval)<= 0)
  491.         tp->v.fval = 1.0;
  492.          else 
  493.         tp->v.fval = 0.0;
  494.          break;        
  495.         }
  496.     case    GEQ: {
  497.          if(cmp(exct(tp->u.child[0])->v.fval,
  498.             exct(tp->u.child[1])->v.fval)>= 0)
  499.         tp->v.fval = 1.0;
  500.          else 
  501.         tp->v.fval = 0.0;
  502.          break;        
  503.         }
  504.     default: {
  505.             foo2();
  506.             sprintf(buf,"kind: %d; op: %d; u.fval: %f; v.fval: %f;   type: %d",tp->kind,tp->op,tp->u.fval,tp->v.fval,tp->type);
  507.             msg(buf);
  508.             i_warning("tried to execute illegal REL in exct");
  509.         }
  510.       }
  511.       break;  /* switch REL */
  512.     } 
  513.   case    OP:{
  514.         tp->type = T_FLOAT;
  515.        switch ((int)tp->op){
  516.         
  517.       case    PLUS: {
  518.                tp->v.fval=exct(tp->u.child[0])->v.fval +    
  519.                               exct(tp->u.child[1])->v.fval;     
  520.             break;
  521.         }
  522.       case    MINUS: {
  523.                tp->v.fval=exct(tp->u.child[0])->v.fval -    
  524.                               exct(tp->u.child[1])->v.fval;     
  525.             break;
  526.         }
  527.       case    MUL: {
  528.                tp->v.fval=exct(tp->u.child[0])->v.fval *    
  529.                               exct(tp->u.child[1])->v.fval;     
  530.             break;
  531.         }
  532.       case    DIV: {
  533.                tp->v.fval=exct(tp->u.child[0])->v.fval /    
  534.                               exct(tp->u.child[1])->v.fval;     
  535.             break;
  536.         }
  537.       case    POW: {
  538.                tp->v.fval=pow(exct(tp->u.child[0])->v.fval ,    
  539.                               exct(tp->u.child[1])->v.fval);
  540.              break; 
  541.         }
  542.     default: {
  543.             foo2();
  544.             sprintf(buf,"kind: %d; op: %d; u.fval: %f; v.fval: %f;   type: %d",tp->kind,tp->op,tp->u.fval,tp->v.fval,tp->type);
  545.             msg(buf);
  546.             i_warning("tried to execute illegal OP in exct");
  547.         }
  548.        }
  549.        break; /*  switch  OP */
  550.                         
  551.        } 
  552.   case       CONVERT: {
  553.         tp->type = T_FLOAT;
  554.         switch (tp->op) {
  555. /******  TBD: THE CONVERSION FUNCTIONS NEED TO BE COMPLETED  ******/
  556.           case    CVTOC: { tp->v.fval=exct(tp->u.child[0])->v.fval;
  557.                 break;
  558.                   } 
  559.           case    CVTOL: { tp->v.fval=exct(tp->u.child[0])->v.fval;
  560.                 break;
  561.                   } 
  562.           case    CVTLO: { tp->v.fval=exct(tp->u.child[0])->v.fval;
  563.                 break;
  564.                   } 
  565.           case    CVTLC: { tp->v.fval=exct(tp->u.child[0])->v.fval;
  566.                 break;
  567.                   } 
  568.           case    CVTCL: { tp->v.fval=exct(tp->u.child[0])->v.fval;
  569.                 break;
  570.                   } 
  571.           case    CVTCO: { tp->v.fval=exct(tp->u.child[0])->v.fval;
  572.                 break;
  573.                   } 
  574.     default: {
  575.             foo2();
  576.             sprintf(buf,"kind: %d; op: %d; u.fval: %f; v.fval: %f;   type: %d",tp->kind,tp->op,tp->u.fval,tp->v.fval,tp->type);
  577.             msg(buf);
  578.             i_warning("tried to execute illegal CVT in exct");
  579.         }
  580.            } 
  581.         break; /* switch CONVERT */    
  582.      }
  583.   case    UNOP: {
  584.         tp->type = T_FLOAT;
  585.         if (tp->op == NEG) 
  586.              tp->v.fval= - exct(tp->u.child[0])->v.fval;
  587.         break;
  588.     }
  589.   case    COR: {
  590.         tp->type = T_FLOAT;
  591.         tp->v.fval = 0;
  592.         if((cmp(0.0,exct(tp->u.child[0])->v.fval)!= 0) ||
  593.              (cmp(0.0,exct(tp->u.child[1])->v.fval)!= 0))
  594.             { tp->v.fval = 1;
  595.             }
  596.         break;
  597.     }
  598.   case    TIF: {
  599.         if (cmp(0.0,exct(tp->u.child[0])->v.fval)!= 0)
  600.             exct(tp->u.child[1]);
  601.         break;
  602.     }
  603.   case    TIFELSE: {
  604.         if (cmp(0.0,exct(tp->u.child[0])->v.fval)!= 0)
  605.             exct(tp->u.child[1]);
  606.         else
  607.             exct(tp->u.child[2]);
  608.         break;
  609.     }
  610.   case    TWHILE: {
  611.         while (cmp(0.0,exct(tp->u.child[0])->v.fval)!= 0)
  612.             exct(tp->u.child[1]);
  613.         break;
  614.     }
  615.   case  TNOOP:  {break;}
  616.   case    TFOR: {
  617. /*
  618.         for (exct(tp->u.child[0]);cmp(0.0,exct(tp->u.child[1])->v.fval)!= 0;
  619.                 exct(tp->u.child[2]))
  620. */
  621.         exct(tp->u.child[0]);
  622.         while (cmp(0.0,exct(tp->u.child[1])->v.fval)!= 0) {
  623.             exct(tp->u.child[3]);
  624.             exct(tp->u.child[2]);
  625.         }
  626.         break;
  627.     }
  628.     default: {
  629.             foo2();
  630.             sprintf(buf,"kind: %d; op: %d; u.fval: %f; v.fval: %f;   type: %d",tp->kind,tp->op,tp->u.fval,tp->v.fval,tp->type);
  631.             msg(buf);
  632.             i_warning("tried to execute illegal node in exct");
  633.         }
  634.  
  635.    }   /*  switch  kind */
  636. return (tp);
  637. }
  638.         
  639.  
  640.  
  641.         
  642. /* keeps a stack of dispatch argument lists */
  643. push_args ()
  644. {
  645.     char *malloc();
  646.         
  647. if (stack_ptr >= MAXSTACK) 
  648.     i_error ("stack overflow: too many nested function calls");
  649. arg_list_stack[stack_ptr] = disp_args;
  650. arg_count_stack[stack_ptr++] = arg_count;
  651. disp_args = (double *) malloc (sizeof(double) * MAXDISPARGS);
  652. arg_count = 0;
  653. }
  654.         
  655. pop_args ()
  656. {
  657. free (disp_args);
  658. if (stack_ptr == 0 ) 
  659.     i_error ("stack underflow");
  660. disp_args = arg_list_stack[--stack_ptr];
  661. arg_count = arg_count_stack[stack_ptr];
  662.         
  663. }
  664.         
  665.         
  666. /*
  667. *
  668. *
  669. *   This recursive function frees space.
  670. *
  671. */
  672.  
  673.  
  674. free_tree(tp)
  675. Tree   tp;
  676. {
  677.  
  678.  
  679. if (tp == NULL) return (NULL);
  680.  
  681. switch (tp->kind)  {
  682.  
  683.    case    SEQ: {
  684.         free_tree(tp->u.child[0]);
  685.         free_tree(tp->u.child[1]);
  686.         break;
  687.     }
  688.    case    STORE: {
  689.         free_tree(tp->u.child[0]);
  690.         free_tree(tp->u.child[1]);
  691.         break;
  692.     }
  693.    case    NAME:  {
  694.         break;
  695.     }
  696.    case    CONST: {
  697.         break;
  698.     }
  699.    case    CONSTF: {
  700.         break;
  701.     }
  702.    case ARG:    {
  703.         free_tree(tp->u.child[0]);
  704.         free_tree(tp->u.child[1]);
  705.         break;
  706.         }
  707.    case NOARGS:  { 
  708.         break;
  709.         }
  710.    case    CALL:   {
  711.         free_tree(tp->u.child[0]);
  712.         break;
  713.     }
  714.    case    NOT: {
  715.         free_tree(tp->u.child[0]);
  716.         break;
  717.     }
  718.    case    CAND: {
  719.         free_tree(tp->u.child[0]);
  720.         free_tree(tp->u.child[1]);
  721.         break;
  722.     }
  723.    case    REL:  {
  724.         free_tree(tp->u.child[0]);
  725.         free_tree(tp->u.child[1]);
  726.         break;
  727.     } 
  728.   case    OP:{
  729.         free_tree(tp->u.child[0]);
  730.         free_tree(tp->u.child[1]);
  731.         break;
  732.        } 
  733.   case       CONVERT: {
  734.         free_tree(tp->u.child[0]);
  735.         break;
  736.      }
  737.   case    UNOP: {
  738.         free_tree(tp->u.child[0]);
  739.         break;
  740.     }
  741.   case    COR: {
  742.         free_tree(tp->u.child[0]);
  743.         free_tree(tp->u.child[1]);
  744.         break;
  745.     }
  746.   case    TIF: {
  747.         free_tree(tp->u.child[0]);
  748.         free_tree(tp->u.child[1]);
  749.         break;
  750.     }
  751.   case    TIFELSE: {
  752.         free_tree(tp->u.child[0]);
  753.         free_tree(tp->u.child[1]);
  754.         free_tree(tp->u.child[2]);
  755.         break;
  756.     }
  757.   case    TWHILE: {
  758.         free_tree(tp->u.child[0]);
  759.         free_tree(tp->u.child[1]);
  760.         break;
  761.     }
  762.   case  TNOOP:  {
  763.         break;
  764.     }
  765.   case    TFOR: {
  766.         free_tree(tp->u.child[0]);
  767.         free_tree(tp->u.child[1]);
  768.         free_tree(tp->u.child[2]);
  769.         free_tree(tp->u.child[3]);
  770.         break;
  771.     }
  772.  
  773.    }   /*  switch  kind */
  774.  
  775. free(tp);  /* actually free space */
  776.  
  777. }
  778.         
  779.